//shell的词法分析程序和语法分析程序，结果返回COMMAND结构体类型，或者报错！
#include"shell.h"

//将字符流转化为单词
WORD Parse1(char stream[]){
    
    WORD word;
    word.next=NULL;
    word.word.next=NULL;
    //使用两个指针，一个指向当前的字符，另一个指向其后一个字符
    char *current=stream;
    if(*current=='\0') {word.word.letter='\0'; return word;}
    char *ahead=stream;
    ahead++;
    WORD *current_WORD;
    current_WORD=&word;
    int flag_ch=0;
    int flag_bl=1;
    Word * current_Word;
    current_WORD->word.letter='\0';
    /*
    *flag_ch用来指示是否已经识别到了字符（非空格）
    *循环进行的操作：逐个识别字符流。当遇到空格，并且下一个还是空格，那么就将两个指针都后移一位，
    *不做其他处理；当遇到空格，下一个为字符时，要判断flag_ch是否为0，如果为0，表示在此前没有出现
    *任何字符，此时不需要进行处理。而当flag_ch!=0时，代表在此之前已经出现过字符了，那么要新创建
    *一个WORD结构体。   当遇到字符时就依次将其进行记录下来，直到遇到空格为止。
    *当ahead为'\0'时表示当次循环为最后一次循环。
    */
   while(*ahead!='\0')
   {
        if(*current==' ')
        {
            flag_bl=1;
            
            if(*ahead==' '){ current++; ahead++;continue;}
            else{
                if(flag_ch==0){current++; ahead++;continue;}
                else{
                    WORD *tmp=(WORD*)malloc(sizeof(WORD));
                    tmp->next=NULL;
                    current_WORD->next=tmp;
                    current_WORD=current_WORD->next;
                    current++;
                    ahead++;
                    continue;
                }
            }
        }
        else{
            if(flag_bl==1){
                current_Word=&current_WORD->word;
                current_Word->letter=*current;
                current_Word->next=NULL;
                current++;
                ahead++;
                
            }
            else{
                Word * tmp=(Word*)malloc(sizeof(Word));
                tmp->letter=*current;
                tmp->next=NULL;
                current_Word->next=tmp;
                current_Word=current_Word->next;
                current++;
                ahead++;
                
            }
            flag_ch=1;
            flag_bl=0;
            continue;
        }
   }
   //对最后一个字符进行处理
   if(*current!=' ')
   {
        //对flag_bl的情况进行判断
        if(flag_bl==0)
        {
            WORD *tmp=(WORD *)malloc(sizeof(WORD));
            tmp->next=NULL;
            current_WORD->next=tmp;
            current_WORD=current_WORD->next;
            current_WORD->word.letter=*current;
            current_WORD->word.next=NULL;
        }
        else{
            Word* tmp=(Word *)malloc(sizeof(Word));
            tmp->letter=*current;
            tmp->next=NULL;
            current_Word->next=tmp;
            current_Word=current_Word->next;
        }
   }
    return word;
}

COMMAND parse_simple(char stream[])
{
    WORD word=Parse1(stream);
    COMMAND command;
    //第一个单词为指令的名称
    WORD * current_WORD;
    current_WORD=&word;
    Word * current_Word;
    current_Word=&(current_WORD->word);
    char name[10];
    int i=0;
    while(current_Word!=NULL)
    {
        name[i]=current_Word->letter;
        i++;
        current_Word=current_Word->next;
    }
    name[i]='\0';
    //指令的名称
    for(int j=0;j<=i;j++)
    {command.name[j]=name[j];}
    current_WORD=current_WORD->next;
    current_Word=&(current_WORD->word);
    if(current_Word->letter=='-') //选项
    {   
        OPTION option;
        OPTION * current_op;
        current_op=&(option);
        current_Word=current_Word->next;
        current_op->op=current_Word->letter;
        current_Word=current_Word->next;
        while(current_Word!=NULL)
        {
            OPTION* tmp=(OPTION*)malloc(sizeof(OPTION));
            tmp->op=current_Word->letter;
            tmp->next=NULL;
            current_op->next=tmp;
            current_op=current_op->next;
        }
        command.op=option;
        current_WORD=current_WORD->next;
        current_Word=&(current_WORD->word);

    }
    else{
        OPTION option;
        option.next=NULL;
        option.op='\0';
        command.op=option;
    }
    //处理变量链
    ARGU argu;
    argu.next=NULL;
    ARGU * current_argu;
    current_argu=&argu;
    int first=1;
    while(current_WORD!=NULL)
    {
        if(first==1) {current_argu->argu=current_WORD->word; current_argu->next=NULL;}
        else{
            ARGU * arg=(ARGU*)malloc(sizeof(ARGU));
            arg->argu=current_WORD->word;
            arg->next=NULL;
            current_argu->next=arg;
            current_argu=current_argu->next;
        }
    }
    command.argu=argu;
    return command;
}

COMMAND parse(char stream[])
{
    /*
    *根据输入流先根据管道符号和重定向符号分割指令，然后将其简单指令的字符流送到parse_simple()中，返回一个简单的
    *COMMAND     在其之前可能将重定向和管道进行相关的记录。
    *根据得到的COMMAND指令和重定向和管道的相关记录补全以及合并COMMAND指令，返回一个最终的COMMAND
    */
   
}